package com.cskaoyan.javase.oop3._2inner._2static._1basic;

/**
 * 在研究具体的访问前，仍先明确以下两点：
 *      1.内部类和外围类是"好兄弟"，它们之间的访问不受访问权限限制，包括私有。
 *      2.静态内部类对象完全不依赖于外围类对象而存在，这意味着，互相访问，不管在哪都要创建对方对象。
 *
 * 静态内部类的访问特点，主要从以下几个角度研究：
 *      1.静态内部类内部访问外围类(重点)
 *          无论在哪里,都是new对象访问,而且不受权限限制
 *
 *      2.外围类访问静态内部类成员(重点)
 *          无论在哪里,都是new对象访问,而且不受权限限制
 *
 *      3.外部类访问静态内部类成员(了解)
 *          无论在哪里,都是直接new静态内部类对象访问,但是全程都会受权限限制.
 *          EnclosedClazz.NestedClazz nc = new EnclosedClazz.NestedClazz();
 *
 *      4.静态内部类访问外部类成员
 *          可以访问,但是全程都受权限限制
 *
 *
 * @since 09:45
 * @author wuguidong@cskaoyan.onaliyun.com
 */
public class Demo {
    public static void main(String[] args) {
        EnclosedClazz.NestedClazz nc = new EnclosedClazz.NestedClazz();
        System.out.println(nc.a);
        // nc.b
        EnclosedClazz.Inner in = new EnclosedClazz().new Inner();
    }
}

class EnclosedClazz {
    int a = 10;
    private int b = 20;
    static int c = 30;
    static final int D = 40;

    class Inner {
    }

    public void test() {
        NestedClazz nc = new NestedClazz();

    }

    public static void testStatic() {
        NestedClazz nc = new NestedClazz();
    }

    static class NestedClazz {
        int a = 100;
        private int b = 200;
        static int c = 300;
        static final int D = 400;

        public void testNested() {
            System.out.println(a);
            System.out.println(b);
            System.out.println(this.a);
            // System.out.println(EnclosedClazz.this.a);
            EnclosedClazz ec = new EnclosedClazz();
            System.out.println(ec.a);
        }

        public static void testNestedStatic() {
            // 这时无论访问谁的成员,都要new对象,包括自己的
        }
    }
}